package com.itheima.leetcode.od.b.recursion_multi;

import java.util.Arrays;
import java.util.TreeSet;

/**
 * (C卷,100分)- 用户调度问题（Java & JS & Python & C）
 * <p>
 * 题目描述
 * <p>
 * 在通信系统中，一个常见的问题是对用户进行不同策略的调度，会得到不同的系统消耗和性能。
 * <p>
 * 假设当前有n个待串行调度用户，每个用户可以使用A/B/C三种不同的调度策略，不同的策略会消耗不同的系统资源。请你根据如下规则进行用户调度，并返回总的消耗资源数。
 * <p>
 * 规则：
 * <p>
 * 相邻的用户不能使用相同的调度策略，例如，第1个用户使用了A策略，则第2个用户只能使用B或者C策略。
 * 对单个用户而言，不同的调度策略对系统资源的消耗可以归一化后抽象为数值。例如，某用户分别使用A/B/C策略的系统消耗分别为15/8/17。
 * 每个用户依次选择当前所能选择的对系统资源消耗最少的策略（局部最优），如果有多个满足要求的策略，选最后一个。
 * <p>
 * 输入描述
 * <p>
 * 第一行表示用户个数n
 * <p>
 * 接下来每一行表示一个用户分别使用三个策略的系统消耗resA resB resC
 * <p>
 * 输出描述
 * <p>
 * 最优策略组合下的总的系统资源消耗数
 * <p>
 * 用例
 * <p>
 * 输入
 * <p>
 * 3
 * <p>
 * 15 8 17
 * <p>
 * 12 20 9
 * <p>
 * 11 7 5
 * <p>
 * 输出	24
 * <p>
 * 说明	1号用户使用B策略，2号用户使用C策略，3号用户使用B策略。系统资源消耗: 8 + 9 + 7 = 24。
 */
public class UserSchedulingProblem {
    public static void main(String[] args) {
        /*Scanner in = new Scanner(System.in);
        int temp = in.nextInt();
        int[][] arr = new int[temp][3];

        for (int i = 0; i < temp; i++) {
            arr[i][0] = in.nextInt();
            arr[i][1] = in.nextInt();
            arr[i][2] = in.nextInt();
        }*/

        int temp = 3;
        int[][] arr = Arrays.stream("15 8 17\n12 20 9\n11 7 5".split("\n"))
                .map(s -> Arrays.stream(s.split(" "))
                        .mapToInt(Integer::parseInt)
                        .toArray())
                .toArray(int[][]::new);

        recursion(arr, 0, temp, arr[0][0], 1);
        recursion(arr, 1, temp, arr[0][1], 1);
        recursion(arr, 2, temp, arr[0][2], 1);

        System.out.println(intSet.first());
    }

    public static TreeSet<Integer> intSet = new TreeSet();

    public static void recursion(int[][] arr, int duplicate, int count, int total, int recursionCount) {
        int left = count - 1;
        if (left == 0) {
            intSet.add(total);
            return;
        }
        if (duplicate == 0) {
            recursion(arr, 1, left, total + arr[recursionCount][1], recursionCount + 1);
            recursion(arr, 2, left, total + arr[recursionCount][2], recursionCount + 1);
        } else if (duplicate == 1) {
            recursion(arr, 0, left, total + arr[recursionCount][0], recursionCount + 1);
            recursion(arr, 2, left, total + arr[recursionCount][2], recursionCount + 1);
        } else if (duplicate == 2) {
            recursion(arr, 0, left, total + arr[recursionCount][0], recursionCount + 1);
            recursion(arr, 1, left, total + arr[recursionCount][1], recursionCount + 1);
        }
    }
}